There are a wide variety of different types of computer systems that are currently in use. It is common to change a deployment of a computer system from one implementation to another implementation. In performing such a reimplementation of a computer system, it can be desired that the behavior of the second implementation be the same as the behavior of the first implementation. In order to ensure that the behavior of the second implementation preserves the behavior found in the first implementation, the behavior of the second system can be verified to ensure that it behaves in the same manner as the first implementation.
Currently, this type of verification is largely performed manually. That is, behavior of the first implementation is manually explored. Then, a user performs manual verification that the same behavior exists in the second implementation.
This type of verification encounters a number of different problems. For instance, verification is often not performed until the second implementation has been fully implemented. At that point, a verification is manually performed by having a user observe the performance of the first implementation and manually verify that it exists in the second implementation. Performing verification after the second implementation has been substantially completed, reduces the likelihood that errors or inconsistencies will be identified early on in the reimplementation process, where they can be more easily remedied. In addition, many current computer systems are so large that manual verification can be very difficult, time consuming, cumbersome, and error prone.
By way of example, some current computer systems are business systems, such as enterprise resource planning (ERP) systems, customer resource management (CRM) systems, line-of-business (LOB) systems, etc. These types of business systems often have many thousands of different forms, each with many different controls. However, it is not uncommon for even these large business systems to be migrated, for instance, from an on-premise implementation to a cloud-based implementation, or vise versa. This type of reimplementation can be very difficult, because it can be very time consuming to ensure that the reimplementation is a behavior-preserving reimplementation. The behavior verification task is simply too burdensome.
The discussion above is merely provided for general background information and is not intended to be used as an aid in determining the scope of the claimed subject matter.